home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / lib / python2.5 / calendar.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-29  |  28KB  |  769 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. '''Calendar printing functions
  5.  
  6. Note when comparing these calendars to the ones printed by cal(1): By
  7. default, these calendars have Monday as the first day of the week, and
  8. Sunday as the last (the European convention). Use setfirstweekday() to
  9. set the first day of the week (0=Monday, 6=Sunday).'''
  10. from __future__ import with_statement
  11. import sys
  12. import datetime
  13. import locale as _locale
  14. __all__ = [
  15.     'IllegalMonthError',
  16.     'IllegalWeekdayError',
  17.     'setfirstweekday',
  18.     'firstweekday',
  19.     'isleap',
  20.     'leapdays',
  21.     'weekday',
  22.     'monthrange',
  23.     'monthcalendar',
  24.     'prmonth',
  25.     'month',
  26.     'prcal',
  27.     'calendar',
  28.     'timegm',
  29.     'month_name',
  30.     'month_abbr',
  31.     'day_name',
  32.     'day_abbr']
  33. error = ValueError
  34.  
  35. class IllegalMonthError(ValueError):
  36.     
  37.     def __init__(self, month):
  38.         self.month = month
  39.  
  40.     
  41.     def __str__(self):
  42.         return 'bad month number %r; must be 1-12' % self.month
  43.  
  44.  
  45.  
  46. class IllegalWeekdayError(ValueError):
  47.     
  48.     def __init__(self, weekday):
  49.         self.weekday = weekday
  50.  
  51.     
  52.     def __str__(self):
  53.         return 'bad weekday number %r; must be 0 (Monday) to 6 (Sunday)' % self.weekday
  54.  
  55.  
  56. January = 1
  57. February = 2
  58. mdays = [
  59.     0,
  60.     31,
  61.     28,
  62.     31,
  63.     30,
  64.     31,
  65.     30,
  66.     31,
  67.     31,
  68.     30,
  69.     31,
  70.     30,
  71.     31]
  72.  
  73. class _localized_month:
  74.     _months = [ datetime.date(2001, i + 1, 1).strftime for i in xrange(12) ]
  75.     _months.insert(0, (lambda x: ''))
  76.     
  77.     def __init__(self, format):
  78.         self.format = format
  79.  
  80.     
  81.     def __getitem__(self, i):
  82.         funcs = self._months[i]
  83.  
  84.     
  85.     def __len__(self):
  86.         return 13
  87.  
  88.  
  89.  
  90. class _localized_day:
  91.     _days = [ datetime.date(2001, 1, i + 1).strftime for i in xrange(7) ]
  92.     
  93.     def __init__(self, format):
  94.         self.format = format
  95.  
  96.     
  97.     def __getitem__(self, i):
  98.         funcs = self._days[i]
  99.  
  100.     
  101.     def __len__(self):
  102.         return 7
  103.  
  104.  
  105. day_name = _localized_day('%A')
  106. day_abbr = _localized_day('%a')
  107. month_name = _localized_month('%B')
  108. month_abbr = _localized_month('%b')
  109. (MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY) = range(7)
  110.  
  111. def isleap(year):
  112.     '''Return 1 for leap years, 0 for non-leap years.'''
  113.     if not year % 4 == 0 and year % 100 != 0:
  114.         pass
  115.     return year % 400 == 0
  116.  
  117.  
  118. def leapdays(y1, y2):
  119.     '''Return number of leap years in range [y1, y2).
  120.        Assume y1 <= y2.'''
  121.     y1 -= 1
  122.     y2 -= 1
  123.     return (y2 // 4 - y1 // 4 - y2 // 100 - y1 // 100) + (y2 // 400 - y1 // 400)
  124.  
  125.  
  126. def weekday(year, month, day):
  127.     '''Return weekday (0-6 ~ Mon-Sun) for year (1970-...), month (1-12),
  128.        day (1-31).'''
  129.     return datetime.date(year, month, day).weekday()
  130.  
  131.  
  132. def monthrange(year, month):
  133.     '''Return weekday (0-6 ~ Mon-Sun) and number of days (28-31) for
  134.        year, month.'''
  135.     if month <= month:
  136.         pass
  137.     elif not month <= 12:
  138.         raise IllegalMonthError(month)
  139.     
  140.     day1 = weekday(year, month, 1)
  141.     if month == February:
  142.         pass
  143.     ndays = mdays[month] + isleap(year)
  144.     return (day1, ndays)
  145.  
  146.  
  147. class Calendar(object):
  148.     """
  149.     Base calendar class. This class doesn't do any formatting. It simply
  150.     provides data to subclasses.
  151.     """
  152.     
  153.     def __init__(self, firstweekday = 0):
  154.         self.firstweekday = firstweekday
  155.  
  156.     
  157.     def getfirstweekday(self):
  158.         return self._firstweekday % 7
  159.  
  160.     
  161.     def setfirstweekday(self, firstweekday):
  162.         self._firstweekday = firstweekday
  163.  
  164.     firstweekday = property(getfirstweekday, setfirstweekday)
  165.     
  166.     def iterweekdays(self):
  167.         '''
  168.         Return a iterator for one week of weekday numbers starting with the
  169.         configured first one.
  170.         '''
  171.         for i in xrange(self.firstweekday, self.firstweekday + 7):
  172.             yield i % 7
  173.         
  174.  
  175.     
  176.     def itermonthdates(self, year, month):
  177.         '''
  178.         Return an iterator for one month. The iterator will yield datetime.date
  179.         values and will always iterate through complete weeks, so it will yield
  180.         dates outside the specified month.
  181.         '''
  182.         date = datetime.date(year, month, 1)
  183.         days = (date.weekday() - self.firstweekday) % 7
  184.         date -= datetime.timedelta(days = days)
  185.         oneday = datetime.timedelta(days = 1)
  186.         while True:
  187.             yield date
  188.             date += oneday
  189.             if date.month != month and date.weekday() == self.firstweekday:
  190.                 break
  191.                 continue
  192.  
  193.     
  194.     def itermonthdays2(self, year, month):
  195.         '''
  196.         Like itermonthdates(), but will yield (day number, weekday number)
  197.         tuples. For days outside the specified month the day number is 0.
  198.         '''
  199.         for date in self.itermonthdates(year, month):
  200.             if date.month != month:
  201.                 yield (0, date.weekday())
  202.                 continue
  203.             yield (date.day, date.weekday())
  204.         
  205.  
  206.     
  207.     def itermonthdays(self, year, month):
  208.         '''
  209.         Like itermonthdates(), but will yield day numbers. For days outside
  210.         the specified month the day number is 0.
  211.         '''
  212.         for date in self.itermonthdates(year, month):
  213.             if date.month != month:
  214.                 yield 0
  215.                 continue
  216.             yield date.day
  217.         
  218.  
  219.     
  220.     def monthdatescalendar(self, year, month):
  221.         """
  222.         Return a matrix (list of lists) representing a month's calendar.
  223.         Each row represents a week; week entries are datetime.date values.
  224.         """
  225.         dates = list(self.itermonthdates(year, month))
  226.         return [ dates[i:i + 7] for i in xrange(0, len(dates), 7) ]
  227.  
  228.     
  229.     def monthdays2calendar(self, year, month):
  230.         """
  231.         Return a matrix representing a month's calendar.
  232.         Each row represents a week; week entries are
  233.         (day number, weekday number) tuples. Day numbers outside this month
  234.         are zero.
  235.         """
  236.         days = list(self.itermonthdays2(year, month))
  237.         return [ days[i:i + 7] for i in xrange(0, len(days), 7) ]
  238.  
  239.     
  240.     def monthdayscalendar(self, year, month):
  241.         """
  242.         Return a matrix representing a month's calendar.
  243.         Each row represents a week; days outside this month are zero.
  244.         """
  245.         days = list(self.itermonthdays(year, month))
  246.         return [ days[i:i + 7] for i in xrange(0, len(days), 7) ]
  247.  
  248.     
  249.     def yeardatescalendar(self, year, width = 3):
  250.         '''
  251.         Return the data for the specified year ready for formatting. The return
  252.         value is a list of month rows. Each month row contains upto width months.
  253.         Each month contains between 4 and 6 weeks and each week contains 1-7
  254.         days. Days are datetime.date objects.
  255.         '''
  256.         months = [ self.monthdatescalendar(year, i) for i in xrange(January, January + 12) ]
  257.         return [ months[i:i + width] for i in xrange(0, len(months), width) ]
  258.  
  259.     
  260.     def yeardays2calendar(self, year, width = 3):
  261.         '''
  262.         Return the data for the specified year ready for formatting (similar to
  263.         yeardatescalendar()). Entries in the week lists are
  264.         (day number, weekday number) tuples. Day numbers outside this month are
  265.         zero.
  266.         '''
  267.         months = [ self.monthdays2calendar(year, i) for i in xrange(January, January + 12) ]
  268.         return [ months[i:i + width] for i in xrange(0, len(months), width) ]
  269.  
  270.     
  271.     def yeardayscalendar(self, year, width = 3):
  272.         '''
  273.         Return the data for the specified year ready for formatting (similar to
  274.         yeardatescalendar()). Entries in the week lists are day numbers.
  275.         Day numbers outside this month are zero.
  276.         '''
  277.         months = [ self.monthdayscalendar(year, i) for i in xrange(January, January + 12) ]
  278.         return [ months[i:i + width] for i in xrange(0, len(months), width) ]
  279.  
  280.  
  281.  
  282. class TextCalendar(Calendar):
  283.     '''
  284.     Subclass of Calendar that outputs a calendar as a simple plain text
  285.     similar to the UNIX program cal.
  286.     '''
  287.     
  288.     def prweek(self, theweek, width):
  289.         '''
  290.         Print a single week (no newline).
  291.         '''
  292.         print self.formatweek(theweek, width),
  293.  
  294.     
  295.     def formatday(self, day, weekday, width):
  296.         '''
  297.         Returns a formatted day.
  298.         '''
  299.         if day == 0:
  300.             s = ''
  301.         else:
  302.             s = '%2i' % day
  303.         return s.center(width)
  304.  
  305.     
  306.     def formatweek(self, theweek, width):
  307.         '''
  308.         Returns a single week in a string (no newline).
  309.         '''
  310.         return (None, ' '.join)((lambda .0: for d, wd in .0:
  311. self.formatday(d, wd, width))(theweek))
  312.  
  313.     
  314.     def formatweekday(self, day, width):
  315.         '''
  316.         Returns a formatted week day name.
  317.         '''
  318.         if width >= 9:
  319.             names = day_name
  320.         else:
  321.             names = day_abbr
  322.         return names[day][:width].center(width)
  323.  
  324.     
  325.     def formatweekheader(self, width):
  326.         '''
  327.         Return a header for a week.
  328.         '''
  329.         return (None, ' '.join)((lambda .0: for i in .0:
  330. self.formatweekday(i, width))(self.iterweekdays()))
  331.  
  332.     
  333.     def formatmonthname(self, theyear, themonth, width, withyear = True):
  334.         '''
  335.         Return a formatted month name.
  336.         '''
  337.         s = month_name[themonth]
  338.         if withyear:
  339.             s = '%s %r' % (s, theyear)
  340.         
  341.         return s.center(width)
  342.  
  343.     
  344.     def prmonth(self, theyear, themonth, w = 0, l = 0):
  345.         """
  346.         Print a month's calendar.
  347.         """
  348.         print self.formatmonth(theyear, themonth, w, l),
  349.  
  350.     
  351.     def formatmonth(self, theyear, themonth, w = 0, l = 0):
  352.         """
  353.         Return a month's calendar string (multi-line).
  354.         """
  355.         w = max(2, w)
  356.         l = max(1, l)
  357.         s = self.formatmonthname(theyear, themonth, 7 * (w + 1) - 1)
  358.         s = s.rstrip()
  359.         s += '\n' * l
  360.         s += self.formatweekheader(w).rstrip()
  361.         s += '\n' * l
  362.         for week in self.monthdays2calendar(theyear, themonth):
  363.             s += self.formatweek(week, w).rstrip()
  364.             s += '\n' * l
  365.         
  366.         return s
  367.  
  368.     
  369.     def formatyear(self, theyear, w = 2, l = 1, c = 6, m = 3):
  370.         """
  371.         Returns a year's calendar as a multi-line string.
  372.         """
  373.         w = max(2, w)
  374.         l = max(1, l)
  375.         c = max(2, c)
  376.         colwidth = (w + 1) * 7 - 1
  377.         v = []
  378.         a = v.append
  379.         a(repr(theyear).center(colwidth * m + c * (m - 1)).rstrip())
  380.         a('\n' * l)
  381.         header = self.formatweekheader(w)
  382.         for i, row in enumerate(self.yeardays2calendar(theyear, m)):
  383.             months = xrange(m * i + 1, min(m * (i + 1) + 1, 13))
  384.             a('\n' * l)
  385.             names = (lambda .0: for k in .0:
  386. self.formatmonthname(theyear, k, colwidth, False))(months)
  387.             a(formatstring(names, colwidth, c).rstrip())
  388.             a('\n' * l)
  389.             headers = (lambda .0: for k in .0:
  390. header)(months)
  391.             a(formatstring(headers, colwidth, c).rstrip())
  392.             a('\n' * l)
  393.             height = max((lambda .0: for cal in .0:
  394. len(cal))(row))
  395.             for j in xrange(height):
  396.                 weeks = []
  397.                 for cal in row:
  398.                     if j >= len(cal):
  399.                         weeks.append('')
  400.                         continue
  401.                     ((None, None, None),)
  402.                     weeks.append(self.formatweek(cal[j], w))
  403.                 
  404.                 a(formatstring(weeks, colwidth, c).rstrip())
  405.                 a('\n' * l)
  406.             
  407.         
  408.         return ''.join(v)
  409.  
  410.     
  411.     def pryear(self, theyear, w = 0, l = 0, c = 6, m = 3):
  412.         """Print a year's calendar."""
  413.         print self.formatyear(theyear, w, l, c, m)
  414.  
  415.  
  416.  
  417. class HTMLCalendar(Calendar):
  418.     '''
  419.     This calendar returns complete HTML pages.
  420.     '''
  421.     cssclasses = [
  422.         'mon',
  423.         'tue',
  424.         'wed',
  425.         'thu',
  426.         'fri',
  427.         'sat',
  428.         'sun']
  429.     
  430.     def formatday(self, day, weekday):
  431.         '''
  432.         Return a day as a table cell.
  433.         '''
  434.         if day == 0:
  435.             return '<td class="noday"> </td>'
  436.         else:
  437.             return '<td class="%s">%d</td>' % (self.cssclasses[weekday], day)
  438.  
  439.     
  440.     def formatweek(self, theweek):
  441.         '''
  442.         Return a complete week as a table row.
  443.         '''
  444.         s = (''.join,)((lambda .0: for d, wd in .0:
  445. self.formatday(d, wd))(theweek))
  446.         return '<tr>%s</tr>' % s
  447.  
  448.     
  449.     def formatweekday(self, day):
  450.         '''
  451.         Return a weekday name as a table header.
  452.         '''
  453.         return '<th class="%s">%s</th>' % (self.cssclasses[day], day_abbr[day])
  454.  
  455.     
  456.     def formatweekheader(self):
  457.         '''
  458.         Return a header for a week as a table row.
  459.         '''
  460.         s = (''.join,)((lambda .0: for i in .0:
  461. self.formatweekday(i))(self.iterweekdays()))
  462.         return '<tr>%s</tr>' % s
  463.  
  464.     
  465.     def formatmonthname(self, theyear, themonth, withyear = True):
  466.         '''
  467.         Return a month name as a table row.
  468.         '''
  469.         if withyear:
  470.             s = '%s %s' % (month_name[themonth], theyear)
  471.         else:
  472.             s = '%s' % month_name[themonth]
  473.         return '<tr><th colspan="7" class="month">%s</th></tr>' % s
  474.  
  475.     
  476.     def formatmonth(self, theyear, themonth, withyear = True):
  477.         '''
  478.         Return a formatted month as a table.
  479.         '''
  480.         v = []
  481.         a = v.append
  482.         a('<table border="0" cellpadding="0" cellspacing="0" class="month">')
  483.         a('\n')
  484.         a(self.formatmonthname(theyear, themonth, withyear = withyear))
  485.         a('\n')
  486.         a(self.formatweekheader())
  487.         a('\n')
  488.         for week in self.monthdays2calendar(theyear, themonth):
  489.             a(self.formatweek(week))
  490.             a('\n')
  491.         
  492.         a('</table>')
  493.         a('\n')
  494.         return ''.join(v)
  495.  
  496.     
  497.     def formatyear(self, theyear, width = 3):
  498.         '''
  499.         Return a formatted year as a table of tables.
  500.         '''
  501.         v = []
  502.         a = v.append
  503.         width = max(width, 1)
  504.         a('<table border="0" cellpadding="0" cellspacing="0" class="year">')
  505.         a('\n')
  506.         a('<tr><th colspan="%d" class="year">%s</th></tr>' % (width, theyear))
  507.         for i in xrange(January, January + 12, width):
  508.             months = xrange(i, min(i + width, 13))
  509.             a('<tr>')
  510.             for m in months:
  511.                 a('<td>')
  512.                 a(self.formatmonth(theyear, m, withyear = False))
  513.                 a('</td>')
  514.             
  515.             a('</tr>')
  516.         
  517.         a('</table>')
  518.         return ''.join(v)
  519.  
  520.     
  521.     def formatyearpage(self, theyear, width = 3, css = 'calendar.css', encoding = None):
  522.         '''
  523.         Return a formatted year as a complete HTML page.
  524.         '''
  525.         if encoding is None:
  526.             encoding = sys.getdefaultencoding()
  527.         
  528.         v = []
  529.         a = v.append
  530.         a('<?xml version="1.0" encoding="%s"?>\n' % encoding)
  531.         a('<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">\n')
  532.         a('<html>\n')
  533.         a('<head>\n')
  534.         a('<meta http-equiv="Content-Type" content="text/html; charset=%s" />\n' % encoding)
  535.         if css is not None:
  536.             a('<link rel="stylesheet" type="text/css" href="%s" />\n' % css)
  537.         
  538.         a('<title>Calendar for %d</title\n' % theyear)
  539.         a('</head>\n')
  540.         a('<body>\n')
  541.         a(self.formatyear(theyear, width))
  542.         a('</body>\n')
  543.         a('</html>\n')
  544.         return ''.join(v).encode(encoding, 'xmlcharrefreplace')
  545.  
  546.  
  547.  
  548. class TimeEncoding:
  549.     
  550.     def __init__(self, locale):
  551.         self.locale = locale
  552.  
  553.     
  554.     def __enter__(self):
  555.         self.oldlocale = _locale.setlocale(_locale.LC_TIME, self.locale)
  556.         return _locale.getlocale(_locale.LC_TIME)[1]
  557.  
  558.     
  559.     def __exit__(self, *args):
  560.         _locale.setlocale(_locale.LC_TIME, self.oldlocale)
  561.  
  562.  
  563.  
  564. class LocaleTextCalendar(TextCalendar):
  565.     '''
  566.     This class can be passed a locale name in the constructor and will return
  567.     month and weekday names in the specified locale. If this locale includes
  568.     an encoding all strings containing month and weekday names will be returned
  569.     as unicode.
  570.     '''
  571.     
  572.     def __init__(self, firstweekday = 0, locale = None):
  573.         TextCalendar.__init__(self, firstweekday)
  574.         if locale is None:
  575.             locale = _locale.getdefaultlocale()
  576.         
  577.         self.locale = locale
  578.  
  579.     
  580.     def formatweekday(self, day, width):
  581.         
  582.         try:
  583.             encoding = _[2]
  584.             if width >= 9:
  585.                 names = day_name
  586.             else:
  587.                 names = day_abbr
  588.             name = names[day]
  589.             if encoding is not None:
  590.                 name = name.decode(encoding)
  591.             
  592.             return name[:width].center(width)
  593.         finally:
  594.             pass
  595.  
  596.  
  597.     
  598.     def formatmonthname(self, theyear, themonth, width, withyear = True):
  599.         
  600.         try:
  601.             encoding = _[2]
  602.             s = month_name[themonth]
  603.             if encoding is not None:
  604.                 s = s.decode(encoding)
  605.             
  606.             if withyear:
  607.                 s = '%s %r' % (s, theyear)
  608.             
  609.             return s.center(width)
  610.         finally:
  611.             pass
  612.  
  613.  
  614.  
  615.  
  616. class LocaleHTMLCalendar(HTMLCalendar):
  617.     '''
  618.     This class can be passed a locale name in the constructor and will return
  619.     month and weekday names in the specified locale. If this locale includes
  620.     an encoding all strings containing month and weekday names will be returned
  621.     as unicode.
  622.     '''
  623.     
  624.     def __init__(self, firstweekday = 0, locale = None):
  625.         HTMLCalendar.__init__(self, firstweekday)
  626.         if locale is None:
  627.             locale = _locale.getdefaultlocale()
  628.         
  629.         self.locale = locale
  630.  
  631.     
  632.     def formatweekday(self, day):
  633.         
  634.         try:
  635.             encoding = _[2]
  636.             s = day_abbr[day]
  637.             if encoding is not None:
  638.                 s = s.decode(encoding)
  639.             
  640.             return '<th class="%s">%s</th>' % (self.cssclasses[day], s)
  641.         finally:
  642.             pass
  643.  
  644.  
  645.     
  646.     def formatmonthname(self, theyear, themonth, withyear = True):
  647.         
  648.         try:
  649.             encoding = _[2]
  650.             s = month_name[themonth]
  651.             if encoding is not None:
  652.                 s = s.decode(encoding)
  653.             
  654.             if withyear:
  655.                 s = '%s %s' % (s, theyear)
  656.             
  657.             return '<tr><th colspan="7" class="month">%s</th></tr>' % s
  658.         finally:
  659.             pass
  660.  
  661.  
  662.  
  663. c = TextCalendar()
  664. firstweekday = c.getfirstweekday
  665.  
  666. def setfirstweekday(firstweekday):
  667.     if firstweekday <= firstweekday:
  668.         pass
  669.     elif not firstweekday <= SUNDAY:
  670.         raise IllegalWeekdayError(firstweekday)
  671.     
  672.     c.firstweekday = firstweekday
  673.  
  674. monthcalendar = c.monthdayscalendar
  675. prweek = c.prweek
  676. week = c.formatweek
  677. weekheader = c.formatweekheader
  678. prmonth = c.prmonth
  679. month = c.formatmonth
  680. calendar = c.formatyear
  681. prcal = c.pryear
  682. _colwidth = 20
  683. _spacing = 6
  684.  
  685. def format(cols, colwidth = _colwidth, spacing = _spacing):
  686.     '''Prints multi-column formatting for year calendars'''
  687.     print formatstring(cols, colwidth, spacing)
  688.  
  689.  
  690. def formatstring(cols, colwidth = _colwidth, spacing = _spacing):
  691.     '''Returns a string formatted from n strings, centered within n columns.'''
  692.     spacing *= ' '
  693.     return (spacing.join,)((lambda .0: for c in .0:
  694. c.center(colwidth))(cols))
  695.  
  696. EPOCH = 1970
  697. _EPOCH_ORD = datetime.date(EPOCH, 1, 1).toordinal()
  698.  
  699. def timegm(tuple):
  700.     '''Unrelated but handy function to calculate Unix timestamp from GMT.'''
  701.     (year, month, day, hour, minute, second) = tuple[:6]
  702.     days = (datetime.date(year, month, 1).toordinal() - _EPOCH_ORD) + day - 1
  703.     hours = days * 24 + hour
  704.     minutes = hours * 60 + minute
  705.     seconds = minutes * 60 + second
  706.     return seconds
  707.  
  708.  
  709. def main(args):
  710.     import optparse as optparse
  711.     parser = optparse.OptionParser(usage = 'usage: %prog [options] [year [month]]')
  712.     parser.add_option('-w', '--width', dest = 'width', type = 'int', default = 2, help = 'width of date column (default 2, text only)')
  713.     parser.add_option('-l', '--lines', dest = 'lines', type = 'int', default = 1, help = 'number of lines for each week (default 1, text only)')
  714.     parser.add_option('-s', '--spacing', dest = 'spacing', type = 'int', default = 6, help = 'spacing between months (default 6, text only)')
  715.     parser.add_option('-m', '--months', dest = 'months', type = 'int', default = 3, help = 'months per row (default 3, text only)')
  716.     parser.add_option('-c', '--css', dest = 'css', default = 'calendar.css', help = 'CSS to use for page (html only)')
  717.     parser.add_option('-L', '--locale', dest = 'locale', default = None, help = 'locale to be used from month and weekday names')
  718.     parser.add_option('-e', '--encoding', dest = 'encoding', default = None, help = 'Encoding to use for output')
  719.     parser.add_option('-t', '--type', dest = 'type', default = 'text', choices = ('text', 'html'), help = 'output type (text or html)')
  720.     (options, args) = parser.parse_args(args)
  721.     if options.locale and not (options.encoding):
  722.         parser.error('if --locale is specified --encoding is required')
  723.         sys.exit(1)
  724.     
  725.     locale = (options.locale, options.encoding)
  726.     if options.type == 'html':
  727.         if options.locale:
  728.             cal = LocaleHTMLCalendar(locale = locale)
  729.         else:
  730.             cal = HTMLCalendar()
  731.         encoding = options.encoding
  732.         if encoding is None:
  733.             encoding = sys.getdefaultencoding()
  734.         
  735.         optdict = dict(encoding = encoding, css = options.css)
  736.         if len(args) == 1:
  737.             print cal.formatyearpage(datetime.date.today().year, **optdict)
  738.         elif len(args) == 2:
  739.             print cal.formatyearpage(int(args[1]), **optdict)
  740.         else:
  741.             parser.error('incorrect number of arguments')
  742.             sys.exit(1)
  743.     elif options.locale:
  744.         cal = LocaleTextCalendar(locale = locale)
  745.     else:
  746.         cal = TextCalendar()
  747.     optdict = dict(w = options.width, l = options.lines)
  748.     if len(args) != 3:
  749.         optdict['c'] = options.spacing
  750.         optdict['m'] = options.months
  751.     
  752.     if len(args) == 1:
  753.         result = cal.formatyear(datetime.date.today().year, **optdict)
  754.     elif len(args) == 2:
  755.         result = cal.formatyear(int(args[1]), **optdict)
  756.     elif len(args) == 3:
  757.         result = cal.formatmonth(int(args[1]), int(args[2]), **optdict)
  758.     else:
  759.         parser.error('incorrect number of arguments')
  760.         sys.exit(1)
  761.     if options.encoding:
  762.         result = result.encode(options.encoding)
  763.     
  764.     print result
  765.  
  766. if __name__ == '__main__':
  767.     main(sys.argv)
  768.  
  769.